package com.apkicon.parser;

import net.dongliu.apk.parser.ApkFile;
import java.io.IOException;
import java.util.zip.ZipFile;
import java.util.zip.ZipEntry;
import java.util.Enumeration;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;

/**
 * APK资源解析器
 * 专门用于解析APK中的资源文件，特别是Adaptive Icon的背景和前景资源
 */
public class ApkResourceResolver {
    
    /**
     * 解析Adaptive Icon的资源引用
     */
    public static AdaptiveIconResources resolveAdaptiveIconResources(ApkFile apk, String adaptiveIconPath) throws IOException {
        System.out.println("🔍 解析Adaptive Icon资源: " + adaptiveIconPath);
        
        // 1. 读取Adaptive Icon XML文件
        byte[] xmlData = apk.getFileData(adaptiveIconPath);
        if (xmlData == null) {
            throw new IOException("无法读取Adaptive Icon XML文件: " + adaptiveIconPath);
        }
        
        // 2. 解析XML内容，提取资源ID
        List<Integer> resourceIds = extractResourceIdsFromXml(xmlData);
        System.out.println("🔍 找到资源ID: " + resourceIds);
        
        // 3. 解析resources.arsc文件来映射资源ID到实际路径
        Map<Integer, String> resourceIdToPath = parseResourcesArsc(apk);
        
        // 4. 查找背景和前景资源
        String backgroundPath = null;
        String foregroundPath = null;
        
        for (Integer resourceId : resourceIds) {
            String path = resourceIdToPath.get(resourceId);
            if (path != null) {
                // 根据文件特征判断是背景还是前景
                if (isBackgroundResource(path, apk)) {
                    backgroundPath = path;
                    System.out.println("🎨 找到背景资源: " + path + " (ID: 0x" + Integer.toHexString(resourceId) + ")");
                } else if (isForegroundResource(path, apk)) {
                    foregroundPath = path;
                    System.out.println("🖼️ 找到前景资源: " + path + " (ID: 0x" + Integer.toHexString(resourceId) + ")");
                }
            }
        }
        
        // 5. 如果通过resources.arsc找不到，使用智能查找
        if (backgroundPath == null || foregroundPath == null) {
            System.out.println("🔍 使用智能查找补充缺失资源...");
            if (backgroundPath == null) {
                backgroundPath = findBackgroundResourceIntelligently(apk);
            }
            if (foregroundPath == null) {
                foregroundPath = findForegroundResourceIntelligently(apk);
            }
        }
        
        return new AdaptiveIconResources(backgroundPath, foregroundPath);
    }
    
    /**
     * 从XML中提取资源ID - 动态检测版本
     */
    private static List<Integer> extractResourceIdsFromXml(byte[] xmlData) {
        List<Integer> resourceIds = new ArrayList<>();
        
        try {
            // 动态查找所有可能的资源ID（4字节小端序）
            for (int i = 0; i <= xmlData.length - 4; i++) {
                // 读取4字节作为资源ID（小端序）
                int resourceId = (xmlData[i] & 0xFF) | 
                                ((xmlData[i+1] & 0xFF) << 8) | 
                                ((xmlData[i+2] & 0xFF) << 16) | 
                                ((xmlData[i+3] & 0xFF) << 24);
                
                // 检查是否是有效的资源ID（通常以0x7f开头）
                if (isValidResourceId(resourceId)) {
                    resourceIds.add(resourceId);
                    System.out.println("✅ 找到资源ID: 0x" + Integer.toHexString(resourceId) + " 在位置: " + i);
                }
            }
            
            // 去重
            resourceIds = resourceIds.stream().distinct().collect(java.util.stream.Collectors.toList());
            System.out.println("🔍 发现其他资源ID: " + resourceIds);
            
        } catch (Exception e) {
            System.err.println("解析XML资源ID失败: " + e.getMessage());
        }
        
        return resourceIds;
    }
    
    /**
     * 检查是否是有效的资源ID
     */
    private static boolean isValidResourceId(int resourceId) {
        // Android资源ID通常以0x7f开头（应用资源）
        // 或者0x01开头（系统资源）
        return (resourceId & 0xFF000000) == 0x7F000000 || 
               (resourceId & 0xFF000000) == 0x01000000;
    }
    
    /**
     * 查找其他可能的资源ID
     */
    private static void findOtherResourceIds(byte[] xmlData, List<Integer> resourceIds) {
        // 查找0x7f开头的资源ID（应用资源ID范围）
        for (int i = 0; i <= xmlData.length - 4; i++) {
            if (xmlData[i+3] == (byte) 0x7f) { // 小端序，高字节在最后
                int resourceId = (xmlData[i] & 0xFF) | 
                               ((xmlData[i+1] & 0xFF) << 8) | 
                               ((xmlData[i+2] & 0xFF) << 16) | 
                               ((xmlData[i+3] & 0xFF) << 24);
                
                if (!resourceIds.contains(resourceId)) {
                    resourceIds.add(resourceId);
                    System.out.println("🔍 发现其他资源ID: 0x" + Integer.toHexString(resourceId) + " 在位置: " + i);
                }
            }
        }
    }
    
    /**
     * 解析resources.arsc文件
     */
    private static Map<Integer, String> parseResourcesArsc(ApkFile apk) {
        Map<Integer, String> resourceIdToPath = new HashMap<>();
        
        try {
            // 尝试读取resources.arsc文件
            byte[] arscData = apk.getFileData("resources.arsc");
            if (arscData != null) {
                System.out.println("📋 找到resources.arsc文件: " + arscData.length + " bytes");
                
                // 使用新的解析器解析resources.arsc
                resourceIdToPath = ResourcesArscParser.parseResourcesArsc(arscData);
                
                if (!resourceIdToPath.isEmpty()) {
                    System.out.println("✅ resources.arsc解析成功，找到 " + resourceIdToPath.size() + " 个资源映射");
                } else {
                    System.out.println("⚠️ resources.arsc解析完成但未找到资源映射，使用智能查找");
                }
            } else {
                System.out.println("❌ 未找到resources.arsc文件");
            }
        } catch (Exception e) {
            System.err.println("解析resources.arsc失败: " + e.getMessage());
        }
        
        return resourceIdToPath;
    }
    
    /**
     * 判断是否为背景资源
     */
    private static boolean isBackgroundResource(String path, ApkFile apk) {
        try {
            byte[] data = apk.getFileData(path);
            if (data != null) {
                // 背景资源通常较大
                if (data.length > 2000) {
                    return true;
                }
                
                // 检查文件名特征
                if (path.contains("bg") || path.contains("background") || path.contains("base")) {
                    return true;
                }
            }
        } catch (Exception e) {
            // 忽略错误
        }
        return false;
    }
    
    /**
     * 判断是否为前景资源
     */
    private static boolean isForegroundResource(String path, ApkFile apk) {
        try {
            byte[] data = apk.getFileData(path);
            if (data != null) {
                // 检查图片尺寸而不是文件大小
                try {
                    BufferedImage image = ImageIO.read(new ByteArrayInputStream(data));
                    if (image != null) {
                        int width = image.getWidth();
                        int height = image.getHeight();
                        
                        // 前景图片应该有合理的尺寸（至少50x50）
                        if (width >= 50 && height >= 50) {
                            return true;
                        }
                        
                        // 如果尺寸太小，不适合作为前景
                        if (width < 30 || height < 30) {
                            return false;
                        }
                    }
                } catch (Exception e) {
                    // 如果无法读取图片，回退到文件大小判断
                }
                
                // 回退：检查文件名特征
                if (path.contains("fg") || path.contains("foreground") || path.contains("icon")) {
                    return true;
                }
                
                // 回退：文件大小判断（但要求更大的文件）
                if (data.length > 200 && data.length < 5000) {
                    return true;
                }
            }
        } catch (Exception e) {
            // 忽略错误
        }
        return false;
    }
    
    /**
     * 智能查找背景资源
     */
    private static String findBackgroundResourceIntelligently(ApkFile apk) {
        try {
            // 查找所有PNG文件
            List<String> pngFiles = findFilesByExtension(apk, ".png");
            
            // 按文件大小排序，选择最大的
            String largestPng = null;
            long maxSize = 0;
            
            for (String pngFile : pngFiles) {
                byte[] data = apk.getFileData(pngFile);
                if (data != null && data.length > maxSize) {
                    maxSize = data.length;
                    largestPng = pngFile;
                }
            }
            
            if (largestPng != null) {
                System.out.println("🎨 智能找到背景资源: " + largestPng + " (" + maxSize + " bytes)");
                return largestPng;
            }
            
        } catch (Exception e) {
            System.err.println("智能查找背景资源失败: " + e.getMessage());
        }
        
        return null;
    }
    
    /**
     * 智能查找前景资源
     */
    private static String findForegroundResourceIntelligently(ApkFile apk) {
        try {
            // 查找所有PNG文件
            List<String> pngFiles = findFilesByExtension(apk, ".png");
            
            // 按文件大小排序，选择中等大小的
            String bestPng = null;
            long bestSize = 0;
            
            for (String pngFile : pngFiles) {
                byte[] data = apk.getFileData(pngFile);
                if (data != null && data.length > 100 && data.length < 1000) {
                    if (bestPng == null || Math.abs(data.length - 500) < Math.abs(bestSize - 500)) {
                        bestSize = data.length;
                        bestPng = pngFile;
                    }
                }
            }
            
            if (bestPng != null) {
                System.out.println("🖼️ 智能找到前景资源: " + bestPng + " (" + bestSize + " bytes)");
                return bestPng;
            }
            
        } catch (Exception e) {
            System.err.println("智能查找前景资源失败: " + e.getMessage());
        }
        
        return null;
    }
    
    /**
     * 查找指定扩展名的文件
     */
    private static List<String> findFilesByExtension(ApkFile apk, String extension) {
        List<String> files = new ArrayList<>();
        
        try {
            // 使用已知的候选文件列表，而不是遍历整个APK
            String[] knownFiles = {
                "res/1I.9.png", "res/zV.9.png", "res/NA.9.png", "res/MF.9.png", "res/qD.9.png",
                "res/-B.png", "res/BM.png", "res/ej.9.png", "res/hZ.9.png", "res/jS1.9.png", 
                "res/1e.9.png", "res/Wh.png", "res/_q.png"
            };
            
            for (String file : knownFiles) {
                if (file.endsWith(extension)) {
                    byte[] data = apk.getFileData(file);
                    if (data != null) {
                        files.add(file);
                    }
                }
            }
            
        } catch (Exception e) {
            System.err.println("查找文件失败: " + e.getMessage());
        }
        
        return files;
    }
    
    /**
     * Adaptive Icon资源信息
     */
    public static class AdaptiveIconResources {
        private final String backgroundPath;
        private final String foregroundPath;
        
        public AdaptiveIconResources(String backgroundPath, String foregroundPath) {
            this.backgroundPath = backgroundPath;
            this.foregroundPath = foregroundPath;
        }
        
        public String getBackgroundPath() { return backgroundPath; }
        public String getForegroundPath() { return foregroundPath; }
        
        public boolean hasBackground() { return backgroundPath != null; }
        public boolean hasForeground() { return foregroundPath != null; }
        
        @Override
        public String toString() {
            return String.format("AdaptiveIconResources{background='%s', foreground='%s'}", 
                               backgroundPath, foregroundPath);
        }
    }
}
